package 时间类

import (
	"bytes"
	"fmt"
	"strconv"
	"strings"
)

// GoString implements fmt.GoStringer interface for Carbon struct.
// 实现 fmt.GoStringer 接口
func (c *Carbon) GoString() string {
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().GoString()
}

// ToString outputs a string in "2006-01-02 15:04:05.999999999 -0700 MST" layout.
// 输出 "2006-01-02 15:04:05.999999999 -0700 MST" 格式字符串
func (c *Carbon) X取完整文本时间(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().String()
}

// ToMonthString outputs a string in month layout like "January", i18n is supported.
// 输出完整月份字符串，支持 i18n
func (c *Carbon) X取完整月份(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	c.lang.rw.RLock()
	defer c.lang.rw.RUnlock()

	if resources, ok := c.lang.resources["months"]; ok {
		slice := strings.Split(resources, "|")
		if len(slice) == X常量_数字_每年12月 {
			return slice[c.X取月()-1]
		}
	}
	return ""
}

// ToShortMonthString outputs a string in short month layout like "Jan", i18n is supported.
// 输出缩写月份字符串，支持 i18n
func (c *Carbon) X取完整月份并简写(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	c.lang.rw.RLock()
	defer c.lang.rw.RUnlock()
	if resources, ok := c.lang.resources["short_months"]; ok {
		slice := strings.Split(resources, "|")
		if len(slice) == X常量_数字_每年12月 {
			return slice[c.X取月()-1]
		}
	}
	return ""
}

// ToWeekString outputs a string in week layout like "Sunday", i18n is supported.
// 输出完整星期字符串，支持 i18n
func (c *Carbon) X取完整星期(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	c.lang.rw.RLock()
	defer c.lang.rw.RUnlock()
	if resources, ok := c.lang.resources["weeks"]; ok {
		slice := strings.Split(resources, "|")
		if len(slice) == X常量_数字_每周7天 {
			return slice[c.X取本周第几天()%X常量_数字_每周7天]
		}
	}
	return ""
}

// ToShortWeekString outputs a string in short week layout like "Sun", i18n is supported.
// 输出缩写星期字符串，支持 i18n
func (c *Carbon) X取完整星期并简写(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	c.lang.rw.RLock()
	defer c.lang.rw.RUnlock()
	if resources, ok := c.lang.resources["short_weeks"]; ok {
		slice := strings.Split(resources, "|")
		if len(slice) == X常量_数字_每周7天 {
			return slice[c.X取本周第几天()%X常量_数字_每周7天]
		}
	}
	return ""
}

// ToDayDateTimeString outputs a string in "Mon, Jan 2, 2006 3:04 PM" layout.
// 输出 "Mon, Jan 2, 2006 3:04 PM" 格式字符串
func (c *Carbon) ToDayDateTimeString(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_DayDateTime)
}

// ToDateTimeString outputs a string in "2006-01-02 15:04:05" layout.
// 输出 "2006-01-02 15:04:05" 格式字符串
func (c *Carbon) X取文本时间(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_DateTime)
}

// ToDateTimeMilliString outputs a string in "2006-01-02 15:04:05.999" layout.
// 输出 "2006-01-02 15:04:05.999" 格式字符串
func (c *Carbon) X取文时间并含毫秒(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_DateTimeMilli)
}

// ToDateTimeMicroString outputs a string in "2006-01-02 15:04:05.999999" layout.
// 输出 "2006-01-02 15:04:05.999999" 格式字符串
func (c *Carbon) X取文本时间并含微秒(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_DateTimeMicro)
}

// ToDateTimeNanoString outputs a string in "2006-01-02 15:04:05.999999999" layout.
// 输出 "2006-01-02 15:04:05.999999999" 格式字符串
func (c *Carbon) X取文本时间并含纳秒(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_DateTimeNano)
}

// ToShortDateTimeString outputs a string in "20060102150405" layout.
// 输出 "20060102150405" 格式字符串
func (c *Carbon) X取简写文本时间(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_ShortDateTime)
}

// ToShortDateTimeMilliString outputs a string in "20060102150405.999" layout.
// 输出 "20060102150405.999" 格式字符串
func (c *Carbon) X取简写文本时间并含毫秒(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_ShortDateTimeMilli)
}

// ToShortDateTimeMicroString outputs a string in "20060102150405.999999" layout.
// 输出 "20060102150405.999999" 格式字符串
func (c *Carbon) X取简写文本时间并含微秒(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_ShortDateTimeMicro)
}

// ToShortDateTimeNanoString outputs a string in "20060102150405.999999999" layout.
// 输出 "20060102150405.999999999" 格式字符串
func (c *Carbon) X取简写文本时间并含纳秒(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_ShortDateTimeNano)
}

// ToDateString outputs a string in "2006-01-02" layout.
// 输出 "2006-01-02" 格式字符串
func (c *Carbon) X取文本日期(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_Date)
}

// ToDateMilliString outputs a string in "2006-01-02.999" layout.
// 输出 "2006-01-02.999" 格式字符串
func (c *Carbon) X取文本日期并含毫秒(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_DateMilli)
}

// ToDateMicroString outputs a string in "2006-01-02.999999" layout.
// 输出 "2006-01-02.999999" 格式字符串
func (c *Carbon) X取文本日期并含微秒(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_DateMicro)
}

// ToDateNanoString outputs a string in "2006-01-02.999999999" layout.
// 输出 "2006-01-02.999999999" 格式字符串
func (c *Carbon) X取文本日期并含纳秒(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_DateNano)
}

// ToShortDateString outputs a string in "20060102" layout.
// 输出 "20060102" 格式字符串
func (c *Carbon) X取简写文本日期(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_ShortDate)
}

// ToShortDateMilliString outputs a string in "20060102.999" layout.
// 输出 "20060102.999" 格式字符串
func (c *Carbon) X取简写文本日期并含毫秒(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_ShortDateMilli)
}

// ToShortDateMicroString outputs a string in "20060102.999999" layout.
// 输出 "20060102.999999" 格式字符串
func (c *Carbon) X取简写文本日期并含微秒(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_ShortDateMicro)
}

// ToShortDateNanoString outputs a string in "20060102.999999999" layout.
// 输出 "20060102.999999999" 格式字符串
func (c *Carbon) X取简写文本日期并含纳秒(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_ShortDateNano)
}

// ToTimeString outputs a string in "15:04:05" layout.
// 输出 "15:04:05" 格式字符串
func (c *Carbon) X取文本时分秒(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_Time)
}

// ToTimeMilliString outputs a string in "15:04:05.999" layout.
// 输出 "15:04:05.999" 格式字符串
func (c *Carbon) X取文本时分秒毫秒(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_TimeMilli)
}

// ToTimeMicroString outputs a string in "15:04:05.999999" layout.
// 输出 "15:04:05.999999" 格式字符串
func (c *Carbon) X取文本时分秒微秒(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_TimeMicro)
}

// ToTimeNanoString outputs a string in "15:04:05.999999999" layout.
// 输出 "15:04:05.999999999" 格式字符串
func (c *Carbon) X取文本时分秒纳秒(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_TimeNano)
}

// ToShortTimeString outputs a string in "150405" layout.
// 输出 "150405" 格式字符串
func (c *Carbon) X取简写文本时分秒(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_ShortTime)
}

// ToShortTimeMilliString outputs a string in "150405.999" layout.
// 输出 "150405.999" 格式字符串
func (c *Carbon) X取简写文本时分秒毫秒(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_ShortTimeMilli)
}

// ToShortTimeMicroString outputs a string in "150405.999999" layout.
// 输出 "150405.999999" 格式字符串
func (c *Carbon) X取简写文本时分秒微秒(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_ShortTimeMicro)
}

// ToShortTimeNanoString outputs a string in "150405.999999999" layout.
// 输出 "150405.999999999" 格式字符串
func (c *Carbon) X取简写文本时分秒纳秒(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_ShortTimeNano)
}

// ToAtomString outputs a string in "2006-01-02T15:04:05Z07:00" layout.
// 输出 "2006-01-02T15:04:05Z07:00" 格式字符串
func (c *Carbon) X取文本时间并按Atom(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_Atom)
}

// ToAnsicString outputs a string in "Mon Jan _2 15:04:05 2006" layout.
// 输出 "Mon Jan _2 15:04:05 2006" 格式字符串
func (c *Carbon) X取文本时间并按ANSIC(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_ANSIC)
}

// ToCookieString outputs a string in "Monday, 02-Jan-2006 15:04:05 MST" layout.
// 输出 "Monday, 02-Jan-2006 15:04:05 MST" 格式字符串
func (c *Carbon) X取文本时间并按Cookie(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_Cookie)
}

// ToRssString outputs a string in "Mon, 02 Jan 2006 15:04:05 -0700" format.
// 输出 "Mon, 02 Jan 2006 15:04:05 -0700" 格式字符串
func (c *Carbon) X取文本时间并按RSS(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_Rss)
}

// ToW3cString outputs a string in "2006-01-02T15:04:05Z07:00" layout.
// 输出 "2006-01-02T15:04:05Z07:00" 格式字符串
func (c *Carbon) X取文本时间并按W3C(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_W3c)
}

// ToUnixDateString outputs a string in "Mon Jan _2 15:04:05 MST 2006" layout.
// 输出 "Mon Jan _2 15:04:05 MST 2006" 格式字符串
func (c *Carbon) X取文本时间并按UnixDate(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_UnixDate)
}

// ToRubyDateString outputs a string in "Mon Jan 02 15:04:05 -0700 2006" layout.
// 输出 "Mon Jan 02 15:04:05 -0700 2006" 格式字符串
func (c *Carbon) X取文本时间并按RubyDate(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_RubyDate)
}

// ToKitchenString outputs a string in "3:04PM" layout.
// 输出 "3:04PM" 格式字符串
func (c *Carbon) X取文本时间并按Kitchen(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_Kitchen)
}

// ToIso8601String outputs a string in "2006-01-02T15:04:05-07:00" layout.
// 输出 "2006-01-02T15:04:05-07:00" 格式字符串
func (c *Carbon) X取文本时间并按ISO8601(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_ISO8601)
}

// ToIso8601MilliString outputs a string in "2006-01-02T15:04:05.999-07:00" layout.
// 输出 "2006-01-02T15:04:05.999-07:00" 格式字符串
func (c *Carbon) X取文本时间并按ISO8601毫秒(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_ISO8601Milli)
}

// ToIso8601MicroString outputs a string in "2006-01-02T15:04:05.999999-07:00" layout.
// 输出 "2006-01-02T15:04:05.999999-07:00" 格式字符串
func (c *Carbon) X取文本时间并按ISO8601微妙(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_ISO8601Micro)
}

// ToIso8601NanoString outputs a string in "2006-01-02T15:04:05.999999999-07:00" layout.
// 输出 "2006-01-02T15:04:05.999999999-07:00" 格式字符串
func (c *Carbon) X取文本时间并按ISO8601纳秒(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_ISO8601Nano)
}

// ToIso8601ZuluString outputs a string in "2006-01-02T15:04:05Z" layout.
// 输出 "2006-01-02T15:04:05Z" 格式字符串
func (c *Carbon) X取文本时间并按ISO8601Z(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_ISO8601Zulu)
}

// ToIso8601ZuluMilliString outputs a string in "2006-01-02T15:04:05.999Z" layout.
// 输出 "2006-01-02T15:04:05.999Z" 格式字符串
func (c *Carbon) X取文本时间并按ISO8601Z毫秒(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_ISO8601ZuluMilli)
}

// ToIso8601ZuluMicroString outputs a string in "2006-01-02T15:04:05.999999Z" layout.
// 输出 "2006-01-02T15:04:05.999999Z" 格式字符串
func (c *Carbon) X取文本时间并按ISO8601Z微妙(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_ISO8601ZuluMicro)
}

// ToIso8601ZuluNanoString outputs a string in "2006-01-02T15:04:05.999999999Z" layout.
// 输出 "2006-01-02T15:04:05.999999999Z" 格式字符串
func (c *Carbon) X取文本时间并按ISO8601Z纳秒(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_ISO8601ZuluNano)
}

// ToRfc822String outputs a string in "02 Jan 06 15:04 MST" layout.
// 输出 "02 Jan 06 15:04 MST" 格式字符串
func (c *Carbon) X取文本时间并按RFC822(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_RFC822)
}

// ToRfc822zString outputs a string in "02 Jan 06 15:04 -0700" layout.
// 输出 "02 Jan 06 15:04 -0700" 格式字符串
func (c *Carbon) X取文本时间并按RFC822Z(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_RFC822Z)
}

// ToRfc850String outputs a string in "Monday, 02-Jan-06 15:04:05 MST" layout.
// 输出 "Monday, 02-Jan-06 15:04:05 MST" 格式字符串
func (c *Carbon) X取文本时间并按RFC850(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_RFC850)
}

// ToRfc1036String outputs a string in "Mon, 02 Jan 06 15:04:05 -0700" layout.
// 输出 "Mon, 02 Jan 06 15:04:05 -0700" 格式字符串
func (c *Carbon) X取文本时间并按RFC1036(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_RFC1036)
}

// ToRfc1123String outputs a string in "Mon, 02 Jan 2006 15:04:05 MST" layout.
// 输出 "Mon, 02 Jan 2006 15:04:05 MST" 格式字符串
func (c *Carbon) X取文本时间并按RFC1123(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_RFC1123)
}

// ToRfc1123zString outputs a string in "Mon, 02 Jan 2006 15:04:05 -0700" layout.
// 输出 "Mon, 02 Jan 2006 15:04:05 -0700" 格式字符串
func (c *Carbon) X取文本时间并按RFC1123Z(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_RFC1123Z)
}

// ToRfc2822String outputs a string in "Mon, 02 Jan 2006 15:04:05 -0700" layout.
// 输出 "Mon, 02 Jan 2006 15:04:05 -0700" 格式字符串
func (c *Carbon) X取文本时间并按RFC2822(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_RFC2822)
}

// ToRfc3339String outputs a string in "2006-01-02T15:04:05Z07:00" layout.
// 输出 "2006-01-02T15:04:05Z07:00" 格式字符串
func (c *Carbon) X取文本时间并按RFC3339(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_RFC3339)
}

// ToRfc3339MilliString outputs a string in "2006-01-02T15:04:05.999Z07:00" layout.
// 输出 "2006-01-02T15:04:05.999Z07:00" 格式字符串
func (c *Carbon) X取文本时间并按RFC3339毫秒(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_RFC3339Milli)
}

// ToRfc3339MicroString outputs a string in "2006-01-02T15:04:05.999999Z07:00" layout.
// 输出 "2006-01-02T15:04:05.999999Z07:00" 格式字符串
func (c *Carbon) X取文本时间并按RFC3339微秒(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_RFC3339Micro)
}

// ToRfc3339NanoString outputs a string in "2006-01-02T15:04:05.999999999Z07:00" layout.
// 输出 "2006-01-02T15:04:05.999999999Z07:00" 格式字符串
func (c *Carbon) X取文本时间并按RFC3339纳秒(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_RFC3339Nano)
}

// ToRfc7231String outputs a string in "Mon, 02 Jan 2006 15:04:05 GMT" layout.
// 输出 "Mon, 02 Jan 2006 15:04:05 GMT" 格式字符串
func (c *Carbon) X取文本时间并按RFC7231(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_RFC7231)
}

// ToFormattedDateString outputs a string in "Jan 2, 2006" layout.
// 输出 "Jan 2, 2006" 格式字符串
func (c *Carbon) ToFormattedDateString(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_FormattedDate)
}

// ToFormattedDayDateString outputs a string in "Mon, Jan 2, 2006" layout.
// 输出 "Jan 2, 2006" 格式字符串
func (c *Carbon) ToFormattedDayDateString(时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	return c.X取Gosdk时间().Format(X常量_布局模板_FormattedDayDate)
}

// Layout outputs a string by layout.
// 输出指定布局模板的时间字符串
func (c *Carbon) X取文本时间并按模板(模板 string, 时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	switch 模板 {
	case X常量_布局模板_Timestamp:
		return strconv.FormatInt(c.X取秒时间戳(), 10)
	case X常量_布局模板_TimestampMilli:
		return strconv.FormatInt(c.X取毫秒时间戳(), 10)
	case X常量_布局模板_TimestampMicro:
		return strconv.FormatInt(c.X取微秒时间戳(), 10)
	case X常量_布局模板_TimestampNano:
		return strconv.FormatInt(c.X取纳秒时间戳(), 10)
	}
	return c.X取Gosdk时间().Format(模板)
}

// Format outputs a string by format.
// 输出指定格式模板的时间字符串
func (c *Carbon) X取文本时间并按格式(格式 string, 时区 ...string) string {
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否为无效时间() {
		return ""
	}
	buffer := &bytes.Buffer{}
	for i := 0; i < len(格式); i++ {
		if layout, ok := formatMap[格式[i]]; ok {
			switch 格式[i] {
			case 'D': // short week, such as Mon
				buffer.WriteString(c.X取完整星期并简写())
			case 'F': // month, such as January
				buffer.WriteString(c.X取完整月份())
			case 'M': // short month, such as Jan
				buffer.WriteString(c.X取完整月份并简写())
			case 'S': // timestamp with second, such as 1596604455
				buffer.WriteString(strconv.FormatInt(c.X取秒时间戳(), 10))
			case 'U': // timestamp with millisecond, such as 1596604455000
				buffer.WriteString(strconv.FormatInt(c.X取毫秒时间戳(), 10))
			case 'V': // timestamp with microsecond, such as 1596604455000000
				buffer.WriteString(strconv.FormatInt(c.X取微秒时间戳(), 10))
			case 'X': // timestamp with nanoseconds, such as 1596604455000000000
				buffer.WriteString(strconv.FormatInt(c.X取纳秒时间戳(), 10))
			default: // common symbols
				buffer.WriteString(c.X取Gosdk时间().Format(layout))
			}
		} else {
			switch 格式[i] {
			case '\\': // raw output, no parse
				buffer.WriteByte(格式[i+1])
				i++
				continue
			case 'W': // week number of the year in ISO-8601 format, ranging from 01-52
				week := fmt.Sprintf("%02d", c.X取本年第几周())
				buffer.WriteString(week)
			case 'N': // day of the week as a number in ISO-8601 format, ranging from 01-7
				week := fmt.Sprintf("%02d", c.X取本周第几天())
				buffer.WriteString(week)
			case 'K': // abbreviated suffix for the day of the month, such as st, nd, rd, th
				suffix := "th"
				switch c.X取日() {
				case 1, 21, 31:
					suffix = "st"
				case 2, 22:
					suffix = "nd"
				case 3, 23:
					suffix = "rd"
				}
				buffer.WriteString(suffix)
			case 'L': // whether it is a leap year, if it is a leap year, it is 1, otherwise it is 0
				if c.X是否为闰年() {
					buffer.WriteString("1")
				} else {
					buffer.WriteString("0")
				}
			case 'G': // 24-hour format, no padding, ranging from 0-23
				buffer.WriteString(strconv.Itoa(c.X取小时()))
			case 'w': // day of the week represented by the number, ranging from 0-6
				buffer.WriteString(strconv.Itoa(c.X取本周第几天() - 1))
			case 't': // number of days in the month, ranging from 28-31
				buffer.WriteString(strconv.Itoa(c.X取本月总天数()))
			case 'z': // current zone location, such as Asia/Tokyo
				buffer.WriteString(c.X取时区位置())
			case 'o': // current zone offset, such as 28800
				buffer.WriteString(strconv.Itoa(c.X取时区偏移量()))
			case 'q': // current quarter, ranging from 1-4
				buffer.WriteString(strconv.Itoa(c.X取季度()))
			case 'c': // current century, ranging from 0-99
				buffer.WriteString(strconv.Itoa(c.X取世纪()))
			default:
				buffer.WriteByte(格式[i])
			}
		}
	}
	return buffer.String()
}
